// 日期格式化
export function parseTime(time: any, pattern?: string) {
    if (arguments.length === 0 || !time) {
      return null;
    }
    const format = pattern || '{y}-{m}-{d} {h}:{i}:{s}';
    let date;
    if (typeof time === 'object') {
      date = time;
    } else {
      if (typeof time === 'string' && /^[0-9]+$/.test(time)) {
        time = parseInt(time);
      } else if (typeof time === 'string') {
        time = time
          .replace(new RegExp(/-/gm), '/')
          .replace('T', ' ')
          .replace(new RegExp(/\.[\d]{3}/gm), '');
      }
      if (typeof time === 'number' && time.toString().length === 10) {
        time = time * 1000;
      }
      date = new Date(time);
    }
    const formatObj: { [key: string]: any } = {
      y: date.getFullYear(),
      m: date.getMonth() + 1,
      d: date.getDate(),
      h: date.getHours(),
      i: date.getMinutes(),
      s: date.getSeconds(),
      a: date.getDay()
    };
    return format.replace(/{(y|m|d|h|i|s|a)+}/g, (result: string, key: string) => {
      let value = formatObj[key];
      // Note: getDay() returns 0 on Sunday
      if (key === 'a') {
        return ['日', '一', '二', '三', '四', '五', '六'][value];
      }
      if (result.length > 0 && value < 10) {
        value = '0' + value;
      }
      return value || 0;
    });
  }
  
  /**
   * 添加日期范围
   * @param params
   * @param dateRange
   * @param propName
   */
  export const addDateRange = (params: any, dateRange: any[], propName?: string) => {
    const search = params;
    search.params = typeof search.params === 'object' && search.params !== null && !Array.isArray(search.params) ? search.params : {};
    dateRange = Array.isArray(dateRange) ? dateRange : [];
    if (typeof propName === 'undefined') {
      search.params['beginTime'] = dateRange[0];
      search.params['endTime'] = dateRange[1];
    } else {
      search.params['begin' + propName] = dateRange[0];
      search.params['end' + propName] = dateRange[1];
    }
    return search;
  };
  
  // 回显数据字典
  export const selectDictLabel = (datas: any, value: number | string) => {
    if (value === undefined) {
      return '';
    }
    const actions = [];
    Object.keys(datas).some((key) => {
      if (datas[key].value == '' + value) {
        actions.push(datas[key].label);
        return true;
      }
    });
    if (actions.length === 0) {
      actions.push(value);
    }
    return actions.join('');
  };
  
  // 回显数据字典（字符串数组）
  export const selectDictLabels = (datas: any, value: any, separator: any) => {
    if (value === undefined || value.length === 0) {
      return '';
    }
    if (Array.isArray(value)) {
      value = value.join(',');
    }
    const actions: any[] = [];
    const currentSeparator = undefined === separator ? ',' : separator;
    const temp = value.split(currentSeparator);
    Object.keys(value.split(currentSeparator)).some((val) => {
      let match = false;
      Object.keys(datas).some((key) => {
        if (datas[key].value == '' + temp[val]) {
          actions.push(datas[key].label + currentSeparator);
          match = true;
        }
      });
      if (!match) {
        actions.push(temp[val] + currentSeparator);
      }
    });
    return actions.join('').substring(0, actions.join('').length - 1);
  };
  
  // 字符串格式化(%s )
  export function sprintf(str: string) {
    if (arguments.length !== 0) {
      let flag = true,
        i = 1;
      str = str.replace(/%s/g, function () {
        const arg = arguments[i++];
        if (typeof arg === 'undefined') {
          flag = false;
          return '';
        }
        return arg;
      });
      return flag ? str : '';
    }
  }
  
  // 转换字符串，undefined,null等转化为""
  export const parseStrEmpty = (str: any) => {
    if (!str || str == 'undefined' || str == 'null') {
      return '';
    }
    return str;
  };
  
  // 数据合并
  export const mergeRecursive = (source: any, target: any) => {
    for (const p in target) {
      try {
        if (target[p].constructor == Object) {
          source[p] = mergeRecursive(source[p], target[p]);
        } else {
          source[p] = target[p];
        }
      } catch (e) {
        source[p] = target[p];
      }
    }
    return source;
  };
  
  /**
   * 构造树型结构数据
   * @param {*} data 数据源
   * @param {*} id id字段 默认 'id'
   * @param {*} parentId 父节点字段 默认 'parentId'
   * @param {*} children 孩子节点字段 默认 'children'
   */
  export const handleTree = <T>(data: any[], id?: string, parentId?: string, children?: string): T[] => {
    const config: {
      id: string;
      parentId: string;
      childrenList: string;
    } = {
      id: id || 'id',
      parentId: parentId || 'parentId',
      childrenList: children || 'children'
    };
  
    const childrenListMap: any = {};
    const nodeIds: any = {};
    const tree: T[] = [];
  
    for (const d of data) {
      const parentId = d[config.parentId];
      if (childrenListMap[parentId] == null) {
        childrenListMap[parentId] = [];
      }
      nodeIds[d[config.id]] = d;
      childrenListMap[parentId].push(d);
    }
  
    for (const d of data) {
      const parentId = d[config.parentId];
      if (nodeIds[parentId] == null) {
        tree.push(d);
      }
    }
    const adaptToChildrenList = (o: any) => {
      if (childrenListMap[o[config.id]] !== null) {
        o[config.childrenList] = childrenListMap[o[config.id]];
      }
      if (o[config.childrenList]) {
        for (const c of o[config.childrenList]) {
          adaptToChildrenList(c);
        }
      }
    };
  
    for (const t of tree) {
      adaptToChildrenList(t);
    }
  
    return tree;
  };
  
  /**
   * 参数处理
   * @param {*} params  参数
   */
  export const tansParams = (params: any) => {
    let result = '';
    for (const propName of Object.keys(params)) {
      const value = params[propName];
      const part = encodeURIComponent(propName) + '=';
      if (value !== null && value !== '' && typeof value !== 'undefined') {
        if (typeof value === 'object') {
          for (const key of Object.keys(value)) {
            if (value[key] !== null && value[key] !== '' && typeof value[key] !== 'undefined') {
              const params = propName + '[' + key + ']';
              const subPart = encodeURIComponent(params) + '=';
              result += subPart + encodeURIComponent(value[key]) + '&';
            }
          }
        } else {
          result += part + encodeURIComponent(value) + '&';
        }
      }
    }
    return result;
  };
  
  // 返回项目路径
  export const getNormalPath = (p: string): string => {
    if (p.length === 0 || !p || p === 'undefined') {
      return p;
    }
    const res = p.replace('//', '/');
    if (res[res.length - 1] === '/') {
      return res.slice(0, res.length - 1);
    }
    return res;
  };
  
  // 验证是否为blob格式
  export const blobValidate = (data: any) => {
    return data.type !== 'application/json';
  };
  
  //通用时间区间
  export const pickerOptions = [
    {
      text: '今天',
      value: () => {
        const end = new Date();
        const start = new Date();
        start.setTime(start.getTime() - 3600 * 1000 * 24 * 0);
        return [start, end];
      }
    },
    {
      text: '昨天',
      value: () => {
        const end = new Date();
        const start = new Date();
        end.setTime(end.getTime() - 3600 * 1000 * 24 * 1)
        start.setTime(start.getTime() - 3600 * 1000 * 24 * 1);
        return [start, end];
      }
    },
    {
      text: '最近一周',
      value: () => {
        const end = new Date();
        const start = new Date();
        start.setTime(start.getTime() - 3600 * 1000 * 24 * 7);
        return [start, end];
      }
    },
    {
      text: '最近一个月',
      value: () => {
        const end = new Date();
        const start = new Date();
        start.setTime(start.getTime() - 3600 * 1000 * 24 * 30);
        return [start, end];
      }
    }
  ];
  
  // 表单重置
  export function resetForm(refName: string) {
    if (this.$refs[refName]) {
      this.$refs[refName].resetFields();
    }
  }
  
  export const formatMoney = (val: string,dp:number = 2) =>  Number(val || 0).toFixed(dp).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
  
  export const filterNull = (obj = {}) => {
    return obj;
    // const computeObj = {}
  
    // for (const [key, value] of Object.entries(obj)) {
    //   computeObj[key] = ['null'].includes(String(value)) ? '' : value
    // }
    // return computeObj
  };
  
  export const nameDesensitize = (name: string) => {
    const arr: any[] = Array.from(name);
  
    let result = '';
    if (arr.length === 2) {
      result = arr[0] + '*';
    } else if (arr.length > 2) {
      for (let i = 1; i < arr.length - 1; i++) {
        arr[i] = '*';
      }
      result = arr.join('');
    } else {
      return name;
    }
    return result;
  };
  
  
  export const renameKeysInTree = (tree, keyMapper) => {
    if (Array.isArray(tree)) {
      return tree.map(node => renameKeysInTree(node, keyMapper));
    } else if (typeof tree === 'object' && tree !== null) {
      const newNode = {};
      for (let oldKey in tree) {
        if (tree.hasOwnProperty(oldKey)) {
          const newKey = keyMapper(oldKey);
          newNode[newKey] = renameKeysInTree(tree[oldKey], keyMapper);
        }
      }
      return newNode;
    } else {
      // 如果不是对象或数组，直接返回原值
      return tree;
    }
  }